// eee.Sheffield.PZ.Imaging
//
// Copyright ?Ping Zou, 2007
// sg71.cherub@gmail.com

using System;
using System.Collections.Generic;
using System.Text;
using eee.Sheffield.PZ.Math;
using System.Drawing;
using System.Drawing.Imaging;

namespace eee.Sheffield.PZ.Imaging.ImageFilter
{
    public class SobelX : DoubleKernel2D //ImageFilter//, IGraylevelImageFilter
    {
        #region Fields
        //private static double[,] _kernelX = new double[,]        
        //{
        //    { 1,  2,  1},
        //    { 0,  0,  0},
        //    {-1, -2, -1}
        //};

        //private string _flag = "[Image -> Gradient -> SobelX]";
        #endregion

        #region Constructor
        public SobelX()
        {
            _flag = "[Image -> Gradient -> SobelX]"; 
            _normalize = true;
            _kernel = new double[,]
	        {
		        { 1,  2,  1},
		        { 0,  0,  0},
		        {-1, -2, -1}
	        };
        }
        #endregion

        //#region Flag
        //public string Flag() { return _flag; }
        //public string Log() { return _log; }
        //#endregion

        #region Apply filter
        //public Bitmap ApplyGraylevelImageFilter(Bitmap srcImage) { return Apply(srcImage, out _log); }
        //public PZMath_matrix ApplyDoubleGraylevelImageFilter(PZMath_matrix srcMatrix) { return ApplyDouble(srcMatrix, out _log); }

        //private Bitmap Apply(Bitmap srcImage, out string logText)
        //{
        //    PZMath_matrix srcMatrix = _converter.ConvertGraylevelBitmapToMatrix(srcImage);
        //    PZMath_matrix dstMatrix = ApplyDouble(srcMatrix, out logText);
        //    Bitmap dstImage = _converter.ConvertMatrixToGraylevelBitmap(dstMatrix, true);
        //    return dstImage;
        //}   

        //protected override PZMath_matrix ApplyDoubleGraylevelImageFilter(PZMath_matrix srcMatrix, out string logText)
        //{
        //    //#region source and dst matrix
        //    //// get source
        //    //int width = srcMatrix.ColumnCount;
        //    //int height = srcMatrix.RowCount;

        //    //// create dstMatrix
        //    //PZMath_matrix dstMatrix = new PZMath_matrix(height, width);
        //    //int heightM1 = height - 1;
        //    //int widthM1 = width - 1;
        //    //int heightM2 = height - 2;
        //    //int widthM2 = width - 2;
        //    //#endregion

        //    //#region apply filter, X direction
        //    //// for each pixel
        //    //for (int y = 1; y < heightM1; y++)
        //    //{
        //    //    for (int x = 1; x < widthM1; x++)
        //    //    {
        //    //        double gx = 0;
        //    //        // for each kernel row
        //    //        for (int i = 0; i < 3; i++)
        //    //        {
        //    //            int ir = i - 1;
        //    //            // for each kernel column
        //    //            for (int j = 0; j < 3; j++)
        //    //            {
        //    //                // source value
        //    //                double v = srcMatrix[y + i - 1, x + j - 1];

        //    //                gx += v * _kernelX[i, j];
        //    //            }
        //    //        }
        //    //        dstMatrix[y, x] = gx;
        //    //    }
        //    //}
        //    //#endregion

        //    //#region copy "margin"
        //    //// for each row
        //    //for (int y = 0; y < height; y++)
        //    //{
        //    //    dstMatrix[y, 0] = dstMatrix[y, 1];
        //    //    dstMatrix[y, widthM1] = dstMatrix[y, widthM2];
        //    //}
        //    //// for each column
        //    //for (int x = 0; x < width; x++)
        //    //{
        //    //    dstMatrix[0, x] = dstMatrix[1, x];
        //    //    dstMatrix[heightM1, x] = dstMatrix[heightM2, x];
        //    //}
        //    //#endregion

        //    PZMath_matrix dstMatrix = srcMatrix.Convolute(new PZMath_matrix(_kernelX));

        //    logText = "succeeds.";
        //    return dstMatrix;
        //}

        ////public PZMath_matrix[] ApplyDouble(PZMath_matrix[] srcMatrix) { return ApplyDouble(srcMatrix, out _log); }
        //protected override PZMath_matrix[] ApplyDoubleColourImageFilter(PZMath_matrix[] srcMatrixArray, out string logText)
        //{
        //    // TODO: verify this function

        //    //#region source and dst matrix
        //    //// get source
        //    //PZMath_matrix srcR = srcMatrixArray[0];
        //    //PZMath_matrix srcG = srcMatrixArray[1];
        //    //PZMath_matrix srcB = srcMatrixArray[2];

        //    //int width = srcR.ColumnCount;
        //    //int height = srcR.RowCount;

        //    //// create dstMatrix
        //    //PZMath_matrix[] dstMatrix = new PZMath_matrix[3];
        //    //dstMatrix[0] = new PZMath_matrix(height, width);
        //    //dstMatrix[1] = new PZMath_matrix(height, width);
        //    //dstMatrix[2] = new PZMath_matrix(height, width);
        //    //PZMath_matrix dstR = dstMatrix[0];
        //    //PZMath_matrix dstG = dstMatrix[1];
        //    //PZMath_matrix dstB = dstMatrix[2];
        //    //int heightM1 = height - 1;
        //    //int widthM1 = width - 1;
        //    //int heightM2 = height - 2;
        //    //int widthM2 = width - 2;
        //    //#endregion

        //    //#region apply filter, X direction
        //    //// for each pixel
        //    //for (int y = 1; y < heightM1; y++)
        //    //{
        //    //    for (int x = 1; x < widthM1; x++)
        //    //    {
        //    //        double gx = 0;
        //    //        // for each kernel row
        //    //        for (int i = 0; i < 3; i++)
        //    //        {
        //    //            int ir = i - 1;
        //    //            // for each kernel column
        //    //            for (int j = 0; j < 3; j++)
        //    //            {
        //    //                // source value
        //    //                double v = srcR[y + i - 1, x + j - 1];

        //    //                gx += v * _kernelX[i, j];
        //    //            }
        //    //        }
        //    //        dstR[y, x] = gx;
        //    //        dstG[y, x] = gx;
        //    //        dstB[y, x] = gx;
        //    //    }
        //    //}
        //    //#endregion

        //    //#region copy "margin"
        //    //// for each row
        //    //for (int y = 0; y < height; y++)
        //    //{
        //    //    dstR[y, 0] = dstR[y, 1];
        //    //    dstG[y, 0] = dstG[y, 1];
        //    //    dstB[y, 0] = dstB[y, 1];
        //    //    dstR[y, widthM1] = dstR[y, widthM2];
        //    //    dstG[y, widthM1] = dstG[y, widthM2];
        //    //    dstB[y, widthM1] = dstB[y, widthM2];
        //    //}
        //    //// for each column
        //    //for (int x = 0; x < width; x++)
        //    //{
        //    //    dstR[0, x] = dstR[1, x];
        //    //    dstG[0, x] = dstG[1, x];
        //    //    dstB[0, x] = dstB[1, x];
        //    //    dstR[heightM1, x] = dstR[heightM2, x];
        //    //    dstG[heightM1, x] = dstG[heightM2, x];
        //    //    dstB[heightM1, x] = dstB[heightM2, x];
        //    //}
        //    //#endregion

        //    PZMath_matrix[] dstMatrixArray = new PZMath_matrix[3];
        //    for (int i = 0; i < 3; i++)
        //        dstMatrixArray[i] = srcMatrixArray[i].Convolute(new PZMath_matrix(_kernelX));

        //    logText = "succeeds.";
        //    return dstMatrixArray;
        //}
        #endregion
    }
}
